Odhin Reports

Run info

Project	Two Circles QA Engineer Tech Test
Release
Test Environment	Localhost
Execution Start Time	Tue, 18 Nov 2025 15:02:29 GMT
Execution End Time	Tue, 18 Nov 2025 15:03:42 GMT
Total Execution Time	0h 1m 13s 0ms

Global Summary

Chart
110

Status	Tests	Percentage
Passed	110	100%
Failed	0	0%
Timed Out	0	0%
Skipped	0	0%
Interrupted	0	0%
Flaky	0	0%

Files Summary

Chart
110

Filename	Tests	Percentage
api_tests/negative-api.spec.ts	20	18.18%
api_tests/get-books.spec.ts	5	4.55%
api_tests/get-book-by-id.spec.ts	5	4.55%
api_tests/post-book.spec.ts	10	9.09%
ui_tests/add-book.spec.ts	35	31.82%
ui_tests/book-details.spec.ts	20	18.18%
ui_tests/library-homepage.spec.ts	5	4.55%
ui_tests/navigation.spec.ts	10	9.09%

Projects Summary

Chart
110

Project	Tests	Percentage
chromium	22	20%
firefox	22	20%
webkit	22	20%
Mobile Chrome	22	20%
Mobile Safari	22	20%

Status by test file

Filename	Tests	Execution Time	Passed
api_tests/negative-api.spec.ts	20	0h 0m 56s 0ms	20 (100%)
api_tests/get-books.spec.ts	5	0h 0m 55s 0ms	5 (100%)
api_tests/get-book-by-id.spec.ts	5	0h 0m 54s 0ms	5 (100%)
api_tests/post-book.spec.ts	10	0h 0m 58s 0ms	10 (100%)
ui_tests/add-book.spec.ts	35	0h 1m 4s 0ms	35 (100%)
ui_tests/book-details.spec.ts	20	0h 1m 5s 0ms	20 (100%)
ui_tests/library-homepage.spec.ts	5	0h 0m 57s 0ms	5 (100%)
ui_tests/navigation.spec.ts	10	0h 0m 59s 0ms	10 (100%)

Status by project

Project	Tests	Execution Time	Passed
chromium	22	0h 0m 17s 0ms	22 (100%)
firefox	22	0h 0m 23s 0ms	22 (100%)
webkit	22	0h 0m 20s 0ms	22 (100%)
Mobile Chrome	22	0h 0m 18s 0ms	22 (100%)
Mobile Safari	22	0h 0m 18s 0ms	22 (100%)

Title	Status	Duration	Retry
Negative => Using only optional fields in payload in POST /api/books throws 400 error	passed	0h 0m 0s 316ms
Negative => Invalid path parameter in GET endpoint throws 404 error	passed	0h 0m 0s 75ms
Positive => GET /api/books fetches all books in library	passed	0h 0m 0s 438ms
Negative => GET /api/books/${bookid} return error if book id is not found	passed	0h 0m 0s 470ms
Positive => GET /api/books/${bookid} fetches book in library using book id	passed	0h 0m 0s 477ms
Negative => Missing required fields in POST /api/books throws 400 error	passed	0h 0m 0s 563ms
E2E => POST /api/books creates new book using all fields	passed	0h 0m 3s 723ms
E2E => POST /api/books creates new book using only required fields	passed	0h 0m 3s 726ms
E2E => Verify user is able Add new book from homepage	passed	0h 0m 5s 704ms
E2E => Verify user is able Add new book from book details page	passed	0h 0m 6s 18ms
Negative => Verify error messages for required fields viz. Title, Author and Pages field on Add New Book form page	passed	0h 0m 2s 883ms
Positive => Verify user is able to open newly added book on details page	passed	0h 0m 7s 2ms
Negative => Verify error messages for optional fields Published Year and Rating field on Add New Book form page	passed	0h 0m 2s 255ms
Positive => Clicking on Cancel button goes back to Library homepage	passed	0h 0m 2s 251ms
Positive => Clicking on View Details link opens book details page	passed	0h 0m 2s 16ms
E2E => Create new book using only required fields	passed	0h 0m 5s 383ms
Positive => Displays details of all default books on Books Library homepage	passed	0h 0m 1s 228ms
Positive => Verify book details page can be accessed using direct url	passed	0h 0m 2s 215ms
Positive => GET /api/books/${bookid} fetches book in library using book id	passed	0h 0m 0s 427ms
E2E => Homepage -> Details page -> Back to Library(using button)	passed	0h 0m 2s 100ms
Negative => Verify book not found text is displayed for non existing book url	passed	0h 0m 3s 124ms
Positive => GET /api/books fetches all books in library	passed	0h 0m 0s 409ms
Negative => GET /api/books/${bookid} return error if book id is not found	passed	0h 0m 0s 420ms
Negative => Invalid path parameter in GET endpoint throws 404 error	passed	0h 0m 0s 58ms
Negative => Using only optional fields in payload in POST /api/books throws 400 error	passed	0h 0m 0s 251ms
Negative => Missing required fields in POST /api/books throws 400 error	passed	0h 0m 0s 515ms
E2E => Homepage -> Details page -> Back to Library(using '←' link)	passed	0h 0m 2s 856ms
E2E => Verify all default books in library have matching details on Book detail page	passed	0h 0m 8s 974ms
E2E => POST /api/books creates new book using all fields	passed	0h 0m 4s 250ms
E2E => POST /api/books creates new book using only required fields	passed	0h 0m 4s 264ms
Negative => Verify error messages for required fields viz. Title, Author and Pages field on Add New Book form page	passed	0h 0m 2s 530ms
E2E => Verify user is able Add new book from homepage	passed	0h 0m 5s 906ms
E2E => Verify user is able Add new book from book details page	passed	0h 0m 6s 786ms
E2E => Create new book using only required fields	passed	0h 0m 5s 109ms
Positive => Clicking on Cancel button goes back to Library homepage	passed	0h 0m 2s 535ms
Positive => Clicking on View Details link opens book details page	passed	0h 0m 2s 437ms
Negative => Verify error messages for optional fields Published Year and Rating field on Add New Book form page	passed	0h 0m 3s 227ms
Positive => Verify user is able to open newly added book on details page	passed	0h 0m 6s 605ms
Positive => Displays details of all default books on Books Library homepage	passed	0h 0m 1s 873ms
Positive => Verify book details page can be accessed using direct url	passed	0h 0m 2s 709ms
Negative => Verify book not found text is displayed for non existing book url	passed	0h 0m 3s 496ms
Positive => GET /api/books/${bookid} fetches book in library using book id	passed	0h 0m 0s 413ms
E2E => Homepage -> Details page -> Back to Library(using button)	passed	0h 0m 3s 292ms
Negative => Missing required fields in POST /api/books throws 400 error	passed	0h 0m 0s 474ms
Negative => GET /api/books/${bookid} return error if book id is not found	passed	0h 0m 0s 389ms
Negative => Invalid path parameter in GET endpoint throws 404 error	passed	0h 0m 0s 71ms
Positive => GET /api/books fetches all books in library	passed	0h 0m 0s 381ms
Negative => Using only optional fields in payload in POST /api/books throws 400 error	passed	0h 0m 0s 287ms
E2E => Homepage -> Details page -> Back to Library(using '←' link)	passed	0h 0m 3s 160ms
E2E => POST /api/books creates new book using all fields	passed	0h 0m 3s 849ms
E2E => POST /api/books creates new book using only required fields	passed	0h 0m 3s 860ms
E2E => Verify all default books in library have matching details on Book detail page	passed	0h 0m 10s 997ms
E2E => Verify user is able Add new book from homepage	passed	0h 0m 5s 387ms
E2E => Verify user is able Add new book from book details page	passed	0h 0m 6s 255ms
Negative => Verify error messages for optional fields Published Year and Rating field on Add New Book form page	passed	0h 0m 2s 320ms
E2E => Create new book using only required fields	passed	0h 0m 5s 183ms
Negative => Verify error messages for required fields viz. Title, Author and Pages field on Add New Book form page	passed	0h 0m 2s 763ms
Positive => Verify user is able to open newly added book on details page	passed	0h 0m 5s 959ms
Positive => Clicking on Cancel button goes back to Library homepage	passed	0h 0m 2s 407ms
Positive => Clicking on View Details link opens book details page	passed	0h 0m 2s 199ms
Positive => Displays details of all default books on Books Library homepage	passed	0h 0m 1s 436ms
Positive => Verify book details page can be accessed using direct url	passed	0h 0m 2s 524ms
E2E => Homepage -> Details page -> Back to Library(using button)	passed	0h 0m 2s 310ms
Positive => GET /api/books/${bookid} fetches book in library using book id	passed	0h 0m 0s 432ms
Negative => Verify book not found text is displayed for non existing book url	passed	0h 0m 3s 153ms
Negative => Missing required fields in POST /api/books throws 400 error	passed	0h 0m 0s 518ms
Positive => GET /api/books fetches all books in library	passed	0h 0m 0s 385ms
Negative => Invalid path parameter in GET endpoint throws 404 error	passed	0h 0m 0s 64ms
Negative => GET /api/books/${bookid} return error if book id is not found	passed	0h 0m 0s 389ms
Negative => Using only optional fields in payload in POST /api/books throws 400 error	passed	0h 0m 0s 256ms
E2E => Homepage -> Details page -> Back to Library(using '←' link)	passed	0h 0m 3s 21ms
E2E => POST /api/books creates new book using all fields	passed	0h 0m 3s 666ms
E2E => POST /api/books creates new book using only required fields	passed	0h 0m 3s 686ms
E2E => Verify all default books in library have matching details on Book detail page	passed	0h 0m 9s 143ms
E2E => Verify user is able Add new book from homepage	passed	0h 0m 5s 565ms
Negative => Verify error messages for required fields viz. Title, Author and Pages field on Add New Book form page	passed	0h 0m 2s 284ms
E2E => Verify user is able Add new book from book details page	passed	0h 0m 6s 14ms
Negative => Verify error messages for optional fields Published Year and Rating field on Add New Book form page	passed	0h 0m 2s 225ms
E2E => Create new book using only required fields	passed	0h 0m 5s 70ms
Positive => Clicking on View Details link opens book details page	passed	0h 0m 2s 142ms
Positive => Verify user is able to open newly added book on details page	passed	0h 0m 5s 914ms
Positive => Clicking on Cancel button goes back to Library homepage	passed	0h 0m 2s 274ms
Positive => Displays details of all default books on Books Library homepage	passed	0h 0m 1s 304ms
Positive => Verify book details page can be accessed using direct url	passed	0h 0m 2s 252ms
E2E => Homepage -> Details page -> Back to Library(using button)	passed	0h 0m 2s 272ms
Positive => GET /api/books/${bookid} fetches book in library using book id	passed	0h 0m 0s 408ms
Negative => Missing required fields in POST /api/books throws 400 error	passed	0h 0m 0s 517ms
Negative => Verify book not found text is displayed for non existing book url	passed	0h 0m 3s 99ms
Negative => Using only optional fields in payload in POST /api/books throws 400 error	passed	0h 0m 0s 258ms
Positive => GET /api/books fetches all books in library	passed	0h 0m 0s 371ms
Negative => Invalid path parameter in GET endpoint throws 404 error	passed	0h 0m 0s 76ms
Negative => GET /api/books/${bookid} return error if book id is not found	passed	0h 0m 0s 410ms
E2E => Homepage -> Details page -> Back to Library(using '←' link)	passed	0h 0m 2s 928ms
E2E => POST /api/books creates new book using all fields	passed	0h 0m 3s 728ms
E2E => POST /api/books creates new book using only required fields	passed	0h 0m 3s 772ms
E2E => Verify all default books in library have matching details on Book detail page	passed	0h 0m 9s 75ms
E2E => Verify user is able Add new book from homepage	passed	0h 0m 5s 101ms
Negative => Verify error messages for required fields viz. Title, Author and Pages field on Add New Book form page	passed	0h 0m 2s 654ms
E2E => Verify user is able Add new book from book details page	passed	0h 0m 6s 171ms
Negative => Verify error messages for optional fields Published Year and Rating field on Add New Book form page	passed	0h 0m 2s 327ms
E2E => Create new book using only required fields	passed	0h 0m 5s 159ms
Positive => Clicking on Cancel button goes back to Library homepage	passed	0h 0m 2s 307ms
Positive => Verify user is able to open newly added book on details page	passed	0h 0m 5s 987ms
Positive => Clicking on View Details link opens book details page	passed	0h 0m 2s 181ms
Positive => Displays details of all default books on Books Library homepage	passed	0h 0m 1s 370ms
Positive => Verify book details page can be accessed using direct url	passed	0h 0m 2s 346ms
E2E => Homepage -> Details page -> Back to Library(using button)	passed	0h 0m 2s 171ms
Negative => Verify book not found text is displayed for non existing book url	passed	0h 0m 3s 65ms
E2E => Homepage -> Details page -> Back to Library(using '←' link)	passed	0h 0m 2s 984ms
E2E => Verify all default books in library have matching details on Book detail page	passed	0h 0m 8s 835ms
Title	Status	Duration	Retry

passed

Negative => Using only optional fields in payload in POST /api/books throws 400 error

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:30 GMT
Total Execution Time	0h 0m 0s 316ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const payload = { genre: 'Fiction' };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

passed

Negative => Invalid path parameter in GET endpoint throws 404 error

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:30 GMT
Total Execution Time	0h 0m 0s 75ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    // Using invalid path parameter 'book' instead of 'books'
    const response = await request.get('/api/book/');
    expect(response.ok()).toBeFalsy();

    const response = await request.get('/api/book/');
    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

passed

Positive => GET /api/books fetches all books in library

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:30 GMT
Total Execution Time	0h 0m 0s 438ms
Retry	0
Test Info
Filename	api_tests/get-books.spec.ts

  
  const response = await request.get('/api/books');
  expect(response.ok()).toBeTruthy();

  const response = await request.get('/api/books');
  expect(response.ok()).toBeTruthy();

  // Verify count of books to be >= default books
  expect(apiBooks.length).toBeGreaterThanOrEqual(library.length);


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }

passed

Negative => GET /api/books/${bookid} return error if book id is not found

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:30 GMT
Total Execution Time	0h 0m 0s 470ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const bookid = 9999;
    const response = await request.get(`/api/books/${bookid}`);
    expect(response.ok()).toBeFalsy();

    const response = await request.get(`/api/books/${bookid}`);
    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

passed

Positive => GET /api/books/${bookid} fetches book in library using book id

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:30 GMT
Total Execution Time	0h 0m 0s 477ms
Retry	0
Test Info
Filename	api_tests/get-book-by-id.spec.ts

  const bookid = 2;
  const response = await request.get(`/api/books/${bookid}`);
  expect(response.ok()).toBeTruthy();

  const response = await request.get(`/api/books/${bookid}`);
  expect(response.ok()).toBeTruthy();

  const apiBook = await response.json();
  expect(apiBook.title).toBe(books[`${bookid-1}`].title);
  expect(apiBook.author).toBe(books[`${bookid-1}`].author);

  expect(apiBook.title).toBe(books[`${bookid-1}`].title);
  expect(apiBook.author).toBe(books[`${bookid-1}`].author);
  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);

  expect(apiBook.author).toBe(books[`${bookid-1}`].author);
  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);
  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);

  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);
  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);
  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));

  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);
  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));
  expect(apiBook.description).toContain(books[`${bookid-1}`].description);

  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));
  expect(apiBook.description).toContain(books[`${bookid-1}`].description);

passed

Negative => Missing required fields in POST /api/books throws 400 error

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:30 GMT
Total Execution Time	0h 0m 0s 563ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const payload = { title: 'POST books test' };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const payload2 = { author: 'Dummy Author' };
    const post2 = await request.post('/api/books', { data: payload2 });
    expect(post2.status()).toBe(400);

    const post2 = await request.post('/api/books', { data: payload2 });
    expect(post2.status()).toBe(400);

passed

E2E => POST /api/books creates new book using all fields

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:30 GMT
Total Execution Time	0h 0m 3s 723ms
Retry	0
Test Info
Group	Validate POST /api/books/ endpoint and verify using GET API and UI (homepage + details)
Filename	api_tests/post-book.spec.ts

                  };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);
    const body = await post.json();

    const body = await post.json();
    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);

    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);

    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe(payload.genre);

    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe(payload.genre);
    expect(body.publishedYear).toBe(payload.publishedYear);

    expect(body.genre).toBe(payload.genre);
    expect(body.publishedYear).toBe(payload.publishedYear);
    expect(body.pages).toBe(payload.pages);

    expect(body.publishedYear).toBe(payload.publishedYear);
    expect(body.pages).toBe(payload.pages);
    expect(body.isbn).toBe(payload.isbn);

    expect(body.pages).toBe(payload.pages);
    expect(body.isbn).toBe(payload.isbn);
    expect(body.description).toContain(payload.description);

    expect(body.isbn).toBe(payload.isbn);
    expect(body.description).toContain(payload.description);

    // Verify the new book is present in the GET /api/books response
    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);

    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);
    const booksList = await getResponse.json();

    const createdBook = booksList.find((b: Book) => b.id === body.id);
    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);

    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    // Verify the new book is present in the GET /api/books/book.id response
    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);

    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);
    const getBook = await getBookResponse.json();

    const getBook = await getBookResponse.json();
    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);

    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe(payload.genre);

    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe(payload.genre);
    expect(getBook.publishedYear).toBe(payload.publishedYear);

    expect(getBook.genre).toBe(payload.genre);
    expect(getBook.publishedYear).toBe(payload.publishedYear);
    expect(getBook.pages).toBe(payload.pages);

    expect(getBook.publishedYear).toBe(payload.publishedYear);
    expect(getBook.pages).toBe(payload.pages);
    expect(getBook.isbn).toBe(payload.isbn);

    expect(getBook.pages).toBe(payload.pages);
    expect(getBook.isbn).toBe(payload.isbn);
    expect(getBook.description).toContain(payload.description);

    expect(getBook.isbn).toBe(payload.isbn);
    expect(getBook.description).toContain(payload.description);

    // Verify via UI that the new book is accessible on Library homepage and details page
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    const bookTitleLocator = page.locator(`text=${payload.title}`);

    const bookTitleLocator = page.locator(`text=${payload.title}`);
    await bookTitleLocator.scrollIntoViewIfNeeded()
    await bookTitleLocator.click();

    await bookTitleLocator.scrollIntoViewIfNeeded()
    await bookTitleLocator.click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitleOnDetails = await page.locator("//h1").innerText();

    const bookTitleOnDetails = await page.locator("//h1").innerText();
    expect(bookTitleOnDetails).toContain(payload.title);

passed

E2E => POST /api/books creates new book using only required fields

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:30 GMT
Total Execution Time	0h 0m 3s 726ms
Retry	0
Test Info
Group	Validate POST /api/books/ endpoint and verify using GET API and UI (homepage + details)
Filename	api_tests/post-book.spec.ts

                  };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);
    const body = await post.json();

    const body = await post.json();
    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);

    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);

    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe('Unknown');

    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe('Unknown');
    expect(body.publishedYear).toBe(2025);

    expect(body.genre).toBe('Unknown');
    expect(body.publishedYear).toBe(2025);
    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **

    expect(body.publishedYear).toBe(2025);
    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **
    expect(body.isbn).toBe('N/A');

    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **
    expect(body.isbn).toBe('N/A');
    expect(body.description).toContain('No description available.');

    expect(body.isbn).toBe('N/A');
    expect(body.description).toContain('No description available.');

    // Verify the new book is present in the GET /api/books response
    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);

    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);
    const booksList = await getResponse.json();

    const createdBook = booksList.find((b: Book) => b.id === body.id);
    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);

    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    // Verify the new book is present in the GET /api/books/book.id response
    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);

    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);
    const getBook = await getBookResponse.json();

    const getBook = await getBookResponse.json();
    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);

    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe('Unknown');

    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe('Unknown');
    expect(getBook.publishedYear).toBe(2025);

    expect(getBook.genre).toBe('Unknown');
    expect(getBook.publishedYear).toBe(2025);
    expect(getBook.pages).toBe(0);

    expect(getBook.publishedYear).toBe(2025);
    expect(getBook.pages).toBe(0);
    expect(getBook.isbn).toBe('N/A');

    expect(getBook.pages).toBe(0);
    expect(getBook.isbn).toBe('N/A');
    expect(getBook.description).toContain('No description available.');

    expect(getBook.isbn).toBe('N/A');
    expect(getBook.description).toContain('No description available.');

    // Verify via UI that the new book is accessible on Library homepage and details page
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    const bookTitleLocator = page.locator(`text=${payload.title}`);

    const bookTitleLocator = page.locator(`text=${payload.title}`);
    await bookTitleLocator.last().scrollIntoViewIfNeeded();
    await bookTitleLocator.last().click();

    await bookTitleLocator.last().scrollIntoViewIfNeeded();
    await bookTitleLocator.last().click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitleOnDetails = await page.locator("//h1").innerText();

    const bookTitleOnDetails = await page.locator("//h1").innerText();
    expect(bookTitleOnDetails).toContain(payload.title);
  });

passed

E2E => Verify user is able Add new book from homepage

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:30 GMT
Total Execution Time	0h 0m 5s 704ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()

    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);

    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);

    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

passed

E2E => Verify user is able Add new book from book details page

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:30 GMT
Total Execution Time	0h 0m 6s 18ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);

    const addAnotherBookButton = page.getByRole('link', { name: 'Add Another Book' });
    await addAnotherBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addAnotherBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()

    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);

    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);

    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

passed

Negative => Verify error messages for required fields viz. Title, Author and Pages field on Add New Book form page

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:34 GMT
Total Execution Time	0h 0m 2s 883ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Verify error message for Title field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(titleErrorMessage);

    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(titleErrorMessage);
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);

    expect(validMessages).toContain(titleErrorMessage);
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);

    // Verify error message for Author field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(authorErrorMessage);

    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(authorErrorMessage);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    expect(validMessages).toContain(authorErrorMessage);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    // Verify error message for Pages field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(pagesErrorMessage);

    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(pagesErrorMessage);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    expect(validMessages).toContain(pagesErrorMessage);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

passed

Positive => Verify user is able to open newly added book on details page

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:30 GMT
Total Execution Time	0h 0m 7s 2ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form using only required fields
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({timeout: 3000});


    await backButton.click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    await page.locator("//*[contains(text(),'Interview preparation-')]").first().click();

    await libraryHeading.waitFor({timeout: 5000});
    await page.locator("//*[contains(text(),'Interview preparation-')]").first().click();


    await backButton.waitFor({ timeout: 3000 });
    const bookTitle = await page.locator("//h1").innerText();

    const bookTitle = await page.locator("//h1").innerText();
    expect(bookTitle).toContain('Interview preparation-');

passed

Negative => Verify error messages for optional fields Published Year and Rating field on Add New Book form page

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:36 GMT
Total Execution Time	0h 0m 2s 255ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    // Verify error message for Published Year field
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('9999999');
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('9999999');
    await page.getByRole('button', { name: 'Add Book' }).click();
    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(yearErrorMessage);

    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(yearErrorMessage);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();

    expect(validMessages).toContain(yearErrorMessage);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('2020');

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('2020');

    // Verify error message for Rating field
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('8');
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('8');
    await page.getByRole('button', { name: 'Add Book' }).click();
    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(ratingErrorMessage);

    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(ratingErrorMessage);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    expect(validMessages).toContain(ratingErrorMessage);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('2');

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('2');

    // Verify error message for Pages field
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

passed

Positive => Clicking on Cancel button goes back to Library homepage

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:37 GMT
Total Execution Time	0h 0m 2s 251ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');


    await page.getByRole('link', { name: 'Cancel' }).click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});

passed

Positive => Clicking on View Details link opens book details page

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:37 GMT
Total Execution Time	0h 0m 2s 16ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const book = books[0];
    await page.locator(`//*[text()='${book.title}']//ancestor::a//*[contains(text(),'View details')]`).click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitle = await page.locator(`text=${book.title}`).textContent();

    const bookTitle = await page.locator(`text=${book.title}`).textContent();
    expect(bookTitle).toBe(`${book.title}`);
    await backLink.click();

    expect(bookTitle).toBe(`${book.title}`);
    await backLink.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();
  });

passed

E2E => Create new book using only required fields

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:34 GMT
Total Execution Time	0h 0m 5s 383ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form using only required fields
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe('Unknown');

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe('Unknown');
    expect(bookPublishedYear).toContain('2025');

    expect(bookGenre).toBe('Unknown');
    expect(bookPublishedYear).toContain('2025');
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain('2025');
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe('N/A');

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe('N/A');
    expect(bookDescription).toContain('No description available.');

    expect(bookISBN).toBe('N/A');
    expect(bookDescription).toContain('No description available.');

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe('Unknown');

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe('Unknown');
    expect(newBookYear).toBe('2025');

    expect(newBookGenre).toBe('Unknown');
    expect(newBookYear).toBe('2025');
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe('2025');
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain('No description available.');

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain('No description available.');
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain('No description available.');
    await expect(newBookRating).toBeVisible();

passed

Positive => Displays details of all default books on Books Library homepage

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:39 GMT
Total Execution Time	0h 0m 1s 228ms
Retry	0
Test Info
Filename	ui_tests/library-homepage.spec.ts

  /** This test will verify each book's details on Library homepage **/
  await page.goto('/');
  const libraryHeading = page.locator("//*[text()='Book Library']");

  const libraryHeading = page.locator("//*[text()='Book Library']");
  await libraryHeading.waitFor({timeout: 5000});


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

passed

Positive => Verify book details page can be accessed using direct url

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:39 GMT
Total Execution Time	0h 0m 2s 215ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });


    await page.goto(firstBookUrl);
    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({ timeout: 3000 });


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toContain(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toContain(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toContain(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookISBN).toBe(book.isbn);

    expect(bookPages).toContain(book.pages);
    expect(bookISBN).toBe(book.isbn);
    expect(bookDescription).toContain(book.description);

    expect(bookISBN).toBe(book.isbn);
    expect(bookDescription).toContain(book.description);

passed

Positive => GET /api/books/${bookid} fetches book in library using book id

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:41 GMT
Total Execution Time	0h 0m 0s 427ms
Retry	0
Test Info
Filename	api_tests/get-book-by-id.spec.ts

  const bookid = 2;
  const response = await request.get(`/api/books/${bookid}`);
  expect(response.ok()).toBeTruthy();

  const response = await request.get(`/api/books/${bookid}`);
  expect(response.ok()).toBeTruthy();

  const apiBook = await response.json();
  expect(apiBook.title).toBe(books[`${bookid-1}`].title);
  expect(apiBook.author).toBe(books[`${bookid-1}`].author);

  expect(apiBook.title).toBe(books[`${bookid-1}`].title);
  expect(apiBook.author).toBe(books[`${bookid-1}`].author);
  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);

  expect(apiBook.author).toBe(books[`${bookid-1}`].author);
  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);
  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);

  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);
  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);
  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));

  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);
  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));
  expect(apiBook.description).toContain(books[`${bookid-1}`].description);

  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));
  expect(apiBook.description).toContain(books[`${bookid-1}`].description);

passed

E2E => Homepage -> Details page -> Back to Library(using button)

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:40 GMT
Total Execution Time	0h 0m 2s 100ms
Retry	0
Test Info
Group	Verify navigations across all pages on app
Filename	ui_tests/navigation.spec.ts

test.describe('Verify navigations across all pages on app', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);
    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({timeout: 3000});


    await backButton.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();
  });

passed

Negative => Verify book not found text is displayed for non existing book url

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:39 GMT
Total Execution Time	0h 0m 3s 124ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const bookUrl = pageUrl + 'book/999';
    const response = await page.goto(bookUrl);
    expect(response?.status()).toBe(200);

    const response = await page.goto(bookUrl);
    expect(response?.status()).toBe(200);

    const bookNotFoundText = await page.locator("text=Book not found").textContent();
    expect(bookNotFoundText).toBe('Book not found');

    const backButton = page.getByRole('link', { name: 'Back to Library' });
    await backButton.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();

passed

Positive => GET /api/books fetches all books in library

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:42 GMT
Total Execution Time	0h 0m 0s 409ms
Retry	0
Test Info
Filename	api_tests/get-books.spec.ts

  
  const response = await request.get('/api/books');
  expect(response.ok()).toBeTruthy();

  const response = await request.get('/api/books');
  expect(response.ok()).toBeTruthy();

  // Verify count of books to be >= default books
  expect(apiBooks.length).toBeGreaterThanOrEqual(library.length);


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }

passed

Negative => GET /api/books/${bookid} return error if book id is not found

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:42 GMT
Total Execution Time	0h 0m 0s 420ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const bookid = 9999;
    const response = await request.get(`/api/books/${bookid}`);
    expect(response.ok()).toBeFalsy();

    const response = await request.get(`/api/books/${bookid}`);
    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

passed

Negative => Invalid path parameter in GET endpoint throws 404 error

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:43 GMT
Total Execution Time	0h 0m 0s 58ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    // Using invalid path parameter 'book' instead of 'books'
    const response = await request.get('/api/book/');
    expect(response.ok()).toBeFalsy();

    const response = await request.get('/api/book/');
    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

passed

Negative => Using only optional fields in payload in POST /api/books throws 400 error

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:42 GMT
Total Execution Time	0h 0m 0s 251ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const payload = { genre: 'Fiction' };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

passed

Negative => Missing required fields in POST /api/books throws 400 error

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:42 GMT
Total Execution Time	0h 0m 0s 515ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const payload = { title: 'POST books test' };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const payload2 = { author: 'Dummy Author' };
    const post2 = await request.post('/api/books', { data: payload2 });
    expect(post2.status()).toBe(400);

    const post2 = await request.post('/api/books', { data: payload2 });
    expect(post2.status()).toBe(400);

passed

E2E => Homepage -> Details page -> Back to Library(using '←' link)

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:41 GMT
Total Execution Time	0h 0m 2s 856ms
Retry	0
Test Info
Group	Verify navigations across all pages on app
Filename	ui_tests/navigation.spec.ts

test.describe('Verify navigations across all pages on app', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({ timeout: 3000 });
    const bookTitle = await page.locator(`text=${firstBook.title}`).innerText();

    const bookTitle = await page.locator(`text=${firstBook.title}`).innerText();
    expect(bookTitle).toBe(firstBook.title);
    await backLink.click();

    expect(bookTitle).toBe(firstBook.title);
    await backLink.click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

passed

E2E => Verify all default books in library have matching details on Book detail page

Run Info
Project	chromium
Execution Start Time	Tue, 18 Nov 2025 15:02:38 GMT
Total Execution Time	0h 0m 8s 974ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

passed

E2E => POST /api/books creates new book using all fields

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:43 GMT
Total Execution Time	0h 0m 4s 250ms
Retry	0
Test Info
Group	Validate POST /api/books/ endpoint and verify using GET API and UI (homepage + details)
Filename	api_tests/post-book.spec.ts

                  };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);
    const body = await post.json();

    const body = await post.json();
    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);

    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);

    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe(payload.genre);

    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe(payload.genre);
    expect(body.publishedYear).toBe(payload.publishedYear);

    expect(body.genre).toBe(payload.genre);
    expect(body.publishedYear).toBe(payload.publishedYear);
    expect(body.pages).toBe(payload.pages);

    expect(body.publishedYear).toBe(payload.publishedYear);
    expect(body.pages).toBe(payload.pages);
    expect(body.isbn).toBe(payload.isbn);

    expect(body.pages).toBe(payload.pages);
    expect(body.isbn).toBe(payload.isbn);
    expect(body.description).toContain(payload.description);

    expect(body.isbn).toBe(payload.isbn);
    expect(body.description).toContain(payload.description);

    // Verify the new book is present in the GET /api/books response
    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);

    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);
    const booksList = await getResponse.json();

    const createdBook = booksList.find((b: Book) => b.id === body.id);
    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);

    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    // Verify the new book is present in the GET /api/books/book.id response
    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);

    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);
    const getBook = await getBookResponse.json();

    const getBook = await getBookResponse.json();
    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);

    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe(payload.genre);

    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe(payload.genre);
    expect(getBook.publishedYear).toBe(payload.publishedYear);

    expect(getBook.genre).toBe(payload.genre);
    expect(getBook.publishedYear).toBe(payload.publishedYear);
    expect(getBook.pages).toBe(payload.pages);

    expect(getBook.publishedYear).toBe(payload.publishedYear);
    expect(getBook.pages).toBe(payload.pages);
    expect(getBook.isbn).toBe(payload.isbn);

    expect(getBook.pages).toBe(payload.pages);
    expect(getBook.isbn).toBe(payload.isbn);
    expect(getBook.description).toContain(payload.description);

    expect(getBook.isbn).toBe(payload.isbn);
    expect(getBook.description).toContain(payload.description);

    // Verify via UI that the new book is accessible on Library homepage and details page
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    const bookTitleLocator = page.locator(`text=${payload.title}`);

    const bookTitleLocator = page.locator(`text=${payload.title}`);
    await bookTitleLocator.scrollIntoViewIfNeeded()
    await bookTitleLocator.click();

    await bookTitleLocator.scrollIntoViewIfNeeded()
    await bookTitleLocator.click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitleOnDetails = await page.locator("//h1").innerText();

    const bookTitleOnDetails = await page.locator("//h1").innerText();
    expect(bookTitleOnDetails).toContain(payload.title);

passed

E2E => POST /api/books creates new book using only required fields

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:43 GMT
Total Execution Time	0h 0m 4s 264ms
Retry	0
Test Info
Group	Validate POST /api/books/ endpoint and verify using GET API and UI (homepage + details)
Filename	api_tests/post-book.spec.ts

                  };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);
    const body = await post.json();

    const body = await post.json();
    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);

    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);

    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe('Unknown');

    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe('Unknown');
    expect(body.publishedYear).toBe(2025);

    expect(body.genre).toBe('Unknown');
    expect(body.publishedYear).toBe(2025);
    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **

    expect(body.publishedYear).toBe(2025);
    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **
    expect(body.isbn).toBe('N/A');

    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **
    expect(body.isbn).toBe('N/A');
    expect(body.description).toContain('No description available.');

    expect(body.isbn).toBe('N/A');
    expect(body.description).toContain('No description available.');

    // Verify the new book is present in the GET /api/books response
    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);

    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);
    const booksList = await getResponse.json();

    const createdBook = booksList.find((b: Book) => b.id === body.id);
    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);

    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    // Verify the new book is present in the GET /api/books/book.id response
    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);

    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);
    const getBook = await getBookResponse.json();

    const getBook = await getBookResponse.json();
    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);

    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe('Unknown');

    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe('Unknown');
    expect(getBook.publishedYear).toBe(2025);

    expect(getBook.genre).toBe('Unknown');
    expect(getBook.publishedYear).toBe(2025);
    expect(getBook.pages).toBe(0);

    expect(getBook.publishedYear).toBe(2025);
    expect(getBook.pages).toBe(0);
    expect(getBook.isbn).toBe('N/A');

    expect(getBook.pages).toBe(0);
    expect(getBook.isbn).toBe('N/A');
    expect(getBook.description).toContain('No description available.');

    expect(getBook.isbn).toBe('N/A');
    expect(getBook.description).toContain('No description available.');

    // Verify via UI that the new book is accessible on Library homepage and details page
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    const bookTitleLocator = page.locator(`text=${payload.title}`);

    const bookTitleLocator = page.locator(`text=${payload.title}`);
    await bookTitleLocator.last().scrollIntoViewIfNeeded();
    await bookTitleLocator.last().click();

    await bookTitleLocator.last().scrollIntoViewIfNeeded();
    await bookTitleLocator.last().click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitleOnDetails = await page.locator("//h1").innerText();

    const bookTitleOnDetails = await page.locator("//h1").innerText();
    expect(bookTitleOnDetails).toContain(payload.title);
  });

passed

Negative => Verify error messages for required fields viz. Title, Author and Pages field on Add New Book form page

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:48 GMT
Total Execution Time	0h 0m 2s 530ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Verify error message for Title field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(titleErrorMessage);

    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(titleErrorMessage);
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);

    expect(validMessages).toContain(titleErrorMessage);
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);

    // Verify error message for Author field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(authorErrorMessage);

    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(authorErrorMessage);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    expect(validMessages).toContain(authorErrorMessage);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    // Verify error message for Pages field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(pagesErrorMessage);

    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(pagesErrorMessage);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    expect(validMessages).toContain(pagesErrorMessage);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

passed

E2E => Verify user is able Add new book from homepage

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:43 GMT
Total Execution Time	0h 0m 5s 906ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()

    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);

    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);

    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

passed

E2E => Verify user is able Add new book from book details page

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:44 GMT
Total Execution Time	0h 0m 6s 786ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);

    const addAnotherBookButton = page.getByRole('link', { name: 'Add Another Book' });
    await addAnotherBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addAnotherBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()

    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);

    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);

    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

passed

E2E => Create new book using only required fields

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:48 GMT
Total Execution Time	0h 0m 5s 109ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form using only required fields
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe('Unknown');

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe('Unknown');
    expect(bookPublishedYear).toContain('2025');

    expect(bookGenre).toBe('Unknown');
    expect(bookPublishedYear).toContain('2025');
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain('2025');
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe('N/A');

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe('N/A');
    expect(bookDescription).toContain('No description available.');

    expect(bookISBN).toBe('N/A');
    expect(bookDescription).toContain('No description available.');

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe('Unknown');

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe('Unknown');
    expect(newBookYear).toBe('2025');

    expect(newBookGenre).toBe('Unknown');
    expect(newBookYear).toBe('2025');
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe('2025');
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain('No description available.');

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain('No description available.');
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain('No description available.');
    await expect(newBookRating).toBeVisible();

passed

Positive => Clicking on Cancel button goes back to Library homepage

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:51 GMT
Total Execution Time	0h 0m 2s 535ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');


    await page.getByRole('link', { name: 'Cancel' }).click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});

passed

Positive => Clicking on View Details link opens book details page

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:51 GMT
Total Execution Time	0h 0m 2s 437ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const book = books[0];
    await page.locator(`//*[text()='${book.title}']//ancestor::a//*[contains(text(),'View details')]`).click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitle = await page.locator(`text=${book.title}`).textContent();

    const bookTitle = await page.locator(`text=${book.title}`).textContent();
    expect(bookTitle).toBe(`${book.title}`);
    await backLink.click();

    expect(bookTitle).toBe(`${book.title}`);
    await backLink.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();
  });

passed

Negative => Verify error messages for optional fields Published Year and Rating field on Add New Book form page

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:51 GMT
Total Execution Time	0h 0m 3s 227ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    // Verify error message for Published Year field
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('9999999');
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('9999999');
    await page.getByRole('button', { name: 'Add Book' }).click();
    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(yearErrorMessage);

    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(yearErrorMessage);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();

    expect(validMessages).toContain(yearErrorMessage);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('2020');

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('2020');

    // Verify error message for Rating field
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('8');
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('8');
    await page.getByRole('button', { name: 'Add Book' }).click();
    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(ratingErrorMessage);

    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(ratingErrorMessage);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    expect(validMessages).toContain(ratingErrorMessage);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('2');

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('2');

    // Verify error message for Pages field
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

passed

Positive => Verify user is able to open newly added book on details page

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:47 GMT
Total Execution Time	0h 0m 6s 605ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form using only required fields
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({timeout: 3000});


    await backButton.click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    await page.locator("//*[contains(text(),'Interview preparation-')]").first().click();

    await libraryHeading.waitFor({timeout: 5000});
    await page.locator("//*[contains(text(),'Interview preparation-')]").first().click();


    await backButton.waitFor({ timeout: 3000 });
    const bookTitle = await page.locator("//h1").innerText();

    const bookTitle = await page.locator("//h1").innerText();
    expect(bookTitle).toContain('Interview preparation-');

passed

Positive => Displays details of all default books on Books Library homepage

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:54 GMT
Total Execution Time	0h 0m 1s 873ms
Retry	0
Test Info
Filename	ui_tests/library-homepage.spec.ts

  /** This test will verify each book's details on Library homepage **/
  await page.goto('/');
  const libraryHeading = page.locator("//*[text()='Book Library']");

  const libraryHeading = page.locator("//*[text()='Book Library']");
  await libraryHeading.waitFor({timeout: 5000});


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

passed

Positive => Verify book details page can be accessed using direct url

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:53 GMT
Total Execution Time	0h 0m 2s 709ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });


    await page.goto(firstBookUrl);
    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({ timeout: 3000 });


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toContain(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toContain(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toContain(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookISBN).toBe(book.isbn);

    expect(bookPages).toContain(book.pages);
    expect(bookISBN).toBe(book.isbn);
    expect(bookDescription).toContain(book.description);

    expect(bookISBN).toBe(book.isbn);
    expect(bookDescription).toContain(book.description);

passed

Negative => Verify book not found text is displayed for non existing book url

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:54 GMT
Total Execution Time	0h 0m 3s 496ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const bookUrl = pageUrl + 'book/999';
    const response = await page.goto(bookUrl);
    expect(response?.status()).toBe(200);

    const response = await page.goto(bookUrl);
    expect(response?.status()).toBe(200);

    const bookNotFoundText = await page.locator("text=Book not found").textContent();
    expect(bookNotFoundText).toBe('Book not found');

    const backButton = page.getByRole('link', { name: 'Back to Library' });
    await backButton.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();

passed

Positive => GET /api/books/${bookid} fetches book in library using book id

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:02:57 GMT
Total Execution Time	0h 0m 0s 413ms
Retry	0
Test Info
Filename	api_tests/get-book-by-id.spec.ts

  const bookid = 2;
  const response = await request.get(`/api/books/${bookid}`);
  expect(response.ok()).toBeTruthy();

  const response = await request.get(`/api/books/${bookid}`);
  expect(response.ok()).toBeTruthy();

  const apiBook = await response.json();
  expect(apiBook.title).toBe(books[`${bookid-1}`].title);
  expect(apiBook.author).toBe(books[`${bookid-1}`].author);

  expect(apiBook.title).toBe(books[`${bookid-1}`].title);
  expect(apiBook.author).toBe(books[`${bookid-1}`].author);
  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);

  expect(apiBook.author).toBe(books[`${bookid-1}`].author);
  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);
  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);

  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);
  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);
  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));

  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);
  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));
  expect(apiBook.description).toContain(books[`${bookid-1}`].description);

  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));
  expect(apiBook.description).toContain(books[`${bookid-1}`].description);

passed

E2E => Homepage -> Details page -> Back to Library(using button)

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:54 GMT
Total Execution Time	0h 0m 3s 292ms
Retry	0
Test Info
Group	Verify navigations across all pages on app
Filename	ui_tests/navigation.spec.ts

test.describe('Verify navigations across all pages on app', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);
    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({timeout: 3000});


    await backButton.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();
  });

passed

Negative => Missing required fields in POST /api/books throws 400 error

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:02:57 GMT
Total Execution Time	0h 0m 0s 474ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const payload = { title: 'POST books test' };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const payload2 = { author: 'Dummy Author' };
    const post2 = await request.post('/api/books', { data: payload2 });
    expect(post2.status()).toBe(400);

    const post2 = await request.post('/api/books', { data: payload2 });
    expect(post2.status()).toBe(400);

passed

Negative => GET /api/books/${bookid} return error if book id is not found

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:02:58 GMT
Total Execution Time	0h 0m 0s 389ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const bookid = 9999;
    const response = await request.get(`/api/books/${bookid}`);
    expect(response.ok()).toBeFalsy();

    const response = await request.get(`/api/books/${bookid}`);
    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

passed

Negative => Invalid path parameter in GET endpoint throws 404 error

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:02:58 GMT
Total Execution Time	0h 0m 0s 71ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    // Using invalid path parameter 'book' instead of 'books'
    const response = await request.get('/api/book/');
    expect(response.ok()).toBeFalsy();

    const response = await request.get('/api/book/');
    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

passed

Positive => GET /api/books fetches all books in library

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:02:58 GMT
Total Execution Time	0h 0m 0s 381ms
Retry	0
Test Info
Filename	api_tests/get-books.spec.ts

  
  const response = await request.get('/api/books');
  expect(response.ok()).toBeTruthy();

  const response = await request.get('/api/books');
  expect(response.ok()).toBeTruthy();

  // Verify count of books to be >= default books
  expect(apiBooks.length).toBeGreaterThanOrEqual(library.length);


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }

passed

Negative => Using only optional fields in payload in POST /api/books throws 400 error

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:02:58 GMT
Total Execution Time	0h 0m 0s 287ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const payload = { genre: 'Fiction' };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

passed

E2E => Homepage -> Details page -> Back to Library(using '←' link)

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:56 GMT
Total Execution Time	0h 0m 3s 160ms
Retry	0
Test Info
Group	Verify navigations across all pages on app
Filename	ui_tests/navigation.spec.ts

test.describe('Verify navigations across all pages on app', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({ timeout: 3000 });
    const bookTitle = await page.locator(`text=${firstBook.title}`).innerText();

    const bookTitle = await page.locator(`text=${firstBook.title}`).innerText();
    expect(bookTitle).toBe(firstBook.title);
    await backLink.click();

    expect(bookTitle).toBe(firstBook.title);
    await backLink.click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

passed

E2E => POST /api/books creates new book using all fields

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:02:58 GMT
Total Execution Time	0h 0m 3s 849ms
Retry	0
Test Info
Group	Validate POST /api/books/ endpoint and verify using GET API and UI (homepage + details)
Filename	api_tests/post-book.spec.ts

                  };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);
    const body = await post.json();

    const body = await post.json();
    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);

    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);

    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe(payload.genre);

    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe(payload.genre);
    expect(body.publishedYear).toBe(payload.publishedYear);

    expect(body.genre).toBe(payload.genre);
    expect(body.publishedYear).toBe(payload.publishedYear);
    expect(body.pages).toBe(payload.pages);

    expect(body.publishedYear).toBe(payload.publishedYear);
    expect(body.pages).toBe(payload.pages);
    expect(body.isbn).toBe(payload.isbn);

    expect(body.pages).toBe(payload.pages);
    expect(body.isbn).toBe(payload.isbn);
    expect(body.description).toContain(payload.description);

    expect(body.isbn).toBe(payload.isbn);
    expect(body.description).toContain(payload.description);

    // Verify the new book is present in the GET /api/books response
    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);

    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);
    const booksList = await getResponse.json();

    const createdBook = booksList.find((b: Book) => b.id === body.id);
    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);

    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    // Verify the new book is present in the GET /api/books/book.id response
    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);

    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);
    const getBook = await getBookResponse.json();

    const getBook = await getBookResponse.json();
    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);

    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe(payload.genre);

    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe(payload.genre);
    expect(getBook.publishedYear).toBe(payload.publishedYear);

    expect(getBook.genre).toBe(payload.genre);
    expect(getBook.publishedYear).toBe(payload.publishedYear);
    expect(getBook.pages).toBe(payload.pages);

    expect(getBook.publishedYear).toBe(payload.publishedYear);
    expect(getBook.pages).toBe(payload.pages);
    expect(getBook.isbn).toBe(payload.isbn);

    expect(getBook.pages).toBe(payload.pages);
    expect(getBook.isbn).toBe(payload.isbn);
    expect(getBook.description).toContain(payload.description);

    expect(getBook.isbn).toBe(payload.isbn);
    expect(getBook.description).toContain(payload.description);

    // Verify via UI that the new book is accessible on Library homepage and details page
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    const bookTitleLocator = page.locator(`text=${payload.title}`);

    const bookTitleLocator = page.locator(`text=${payload.title}`);
    await bookTitleLocator.scrollIntoViewIfNeeded()
    await bookTitleLocator.click();

    await bookTitleLocator.scrollIntoViewIfNeeded()
    await bookTitleLocator.click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitleOnDetails = await page.locator("//h1").innerText();

    const bookTitleOnDetails = await page.locator("//h1").innerText();
    expect(bookTitleOnDetails).toContain(payload.title);

passed

E2E => POST /api/books creates new book using only required fields

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:02:58 GMT
Total Execution Time	0h 0m 3s 860ms
Retry	0
Test Info
Group	Validate POST /api/books/ endpoint and verify using GET API and UI (homepage + details)
Filename	api_tests/post-book.spec.ts

                  };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);
    const body = await post.json();

    const body = await post.json();
    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);

    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);

    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe('Unknown');

    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe('Unknown');
    expect(body.publishedYear).toBe(2025);

    expect(body.genre).toBe('Unknown');
    expect(body.publishedYear).toBe(2025);
    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **

    expect(body.publishedYear).toBe(2025);
    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **
    expect(body.isbn).toBe('N/A');

    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **
    expect(body.isbn).toBe('N/A');
    expect(body.description).toContain('No description available.');

    expect(body.isbn).toBe('N/A');
    expect(body.description).toContain('No description available.');

    // Verify the new book is present in the GET /api/books response
    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);

    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);
    const booksList = await getResponse.json();

    const createdBook = booksList.find((b: Book) => b.id === body.id);
    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);

    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    // Verify the new book is present in the GET /api/books/book.id response
    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);

    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);
    const getBook = await getBookResponse.json();

    const getBook = await getBookResponse.json();
    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);

    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe('Unknown');

    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe('Unknown');
    expect(getBook.publishedYear).toBe(2025);

    expect(getBook.genre).toBe('Unknown');
    expect(getBook.publishedYear).toBe(2025);
    expect(getBook.pages).toBe(0);

    expect(getBook.publishedYear).toBe(2025);
    expect(getBook.pages).toBe(0);
    expect(getBook.isbn).toBe('N/A');

    expect(getBook.pages).toBe(0);
    expect(getBook.isbn).toBe('N/A');
    expect(getBook.description).toContain('No description available.');

    expect(getBook.isbn).toBe('N/A');
    expect(getBook.description).toContain('No description available.');

    // Verify via UI that the new book is accessible on Library homepage and details page
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    const bookTitleLocator = page.locator(`text=${payload.title}`);

    const bookTitleLocator = page.locator(`text=${payload.title}`);
    await bookTitleLocator.last().scrollIntoViewIfNeeded();
    await bookTitleLocator.last().click();

    await bookTitleLocator.last().scrollIntoViewIfNeeded();
    await bookTitleLocator.last().click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitleOnDetails = await page.locator("//h1").innerText();

    const bookTitleOnDetails = await page.locator("//h1").innerText();
    expect(bookTitleOnDetails).toContain(payload.title);
  });

passed

E2E => Verify all default books in library have matching details on Book detail page

Run Info
Project	firefox
Execution Start Time	Tue, 18 Nov 2025 15:02:53 GMT
Total Execution Time	0h 0m 10s 997ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

passed

E2E => Verify user is able Add new book from homepage

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:02:59 GMT
Total Execution Time	0h 0m 5s 387ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()

    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);

    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);

    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

passed

E2E => Verify user is able Add new book from book details page

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:00 GMT
Total Execution Time	0h 0m 6s 255ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);

    const addAnotherBookButton = page.getByRole('link', { name: 'Add Another Book' });
    await addAnotherBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addAnotherBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()

    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);

    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);

    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

passed

Negative => Verify error messages for optional fields Published Year and Rating field on Add New Book form page

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:04 GMT
Total Execution Time	0h 0m 2s 320ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    // Verify error message for Published Year field
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('9999999');
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('9999999');
    await page.getByRole('button', { name: 'Add Book' }).click();
    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(yearErrorMessage);

    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(yearErrorMessage);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();

    expect(validMessages).toContain(yearErrorMessage);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('2020');

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('2020');

    // Verify error message for Rating field
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('8');
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('8');
    await page.getByRole('button', { name: 'Add Book' }).click();
    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(ratingErrorMessage);

    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(ratingErrorMessage);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    expect(validMessages).toContain(ratingErrorMessage);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('2');

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('2');

    // Verify error message for Pages field
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

passed

E2E => Create new book using only required fields

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:02 GMT
Total Execution Time	0h 0m 5s 183ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form using only required fields
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe('Unknown');

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe('Unknown');
    expect(bookPublishedYear).toContain('2025');

    expect(bookGenre).toBe('Unknown');
    expect(bookPublishedYear).toContain('2025');
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain('2025');
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe('N/A');

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe('N/A');
    expect(bookDescription).toContain('No description available.');

    expect(bookISBN).toBe('N/A');
    expect(bookDescription).toContain('No description available.');

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe('Unknown');

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe('Unknown');
    expect(newBookYear).toBe('2025');

    expect(newBookGenre).toBe('Unknown');
    expect(newBookYear).toBe('2025');
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe('2025');
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain('No description available.');

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain('No description available.');
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain('No description available.');
    await expect(newBookRating).toBeVisible();

passed

Negative => Verify error messages for required fields viz. Title, Author and Pages field on Add New Book form page

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:05 GMT
Total Execution Time	0h 0m 2s 763ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Verify error message for Title field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(titleErrorMessage);

    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(titleErrorMessage);
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);

    expect(validMessages).toContain(titleErrorMessage);
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);

    // Verify error message for Author field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(authorErrorMessage);

    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(authorErrorMessage);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    expect(validMessages).toContain(authorErrorMessage);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    // Verify error message for Pages field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(pagesErrorMessage);

    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(pagesErrorMessage);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    expect(validMessages).toContain(pagesErrorMessage);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

passed

Positive => Verify user is able to open newly added book on details page

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:02 GMT
Total Execution Time	0h 0m 5s 959ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form using only required fields
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({timeout: 3000});


    await backButton.click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    await page.locator("//*[contains(text(),'Interview preparation-')]").first().click();

    await libraryHeading.waitFor({timeout: 5000});
    await page.locator("//*[contains(text(),'Interview preparation-')]").first().click();


    await backButton.waitFor({ timeout: 3000 });
    const bookTitle = await page.locator("//h1").innerText();

    const bookTitle = await page.locator("//h1").innerText();
    expect(bookTitle).toContain('Interview preparation-');

passed

Positive => Clicking on Cancel button goes back to Library homepage

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:06 GMT
Total Execution Time	0h 0m 2s 407ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');


    await page.getByRole('link', { name: 'Cancel' }).click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});

passed

Positive => Clicking on View Details link opens book details page

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:07 GMT
Total Execution Time	0h 0m 2s 199ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const book = books[0];
    await page.locator(`//*[text()='${book.title}']//ancestor::a//*[contains(text(),'View details')]`).click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitle = await page.locator(`text=${book.title}`).textContent();

    const bookTitle = await page.locator(`text=${book.title}`).textContent();
    expect(bookTitle).toBe(`${book.title}`);
    await backLink.click();

    expect(bookTitle).toBe(`${book.title}`);
    await backLink.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();
  });

passed

Positive => Displays details of all default books on Books Library homepage

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:09 GMT
Total Execution Time	0h 0m 1s 436ms
Retry	0
Test Info
Filename	ui_tests/library-homepage.spec.ts

  /** This test will verify each book's details on Library homepage **/
  await page.goto('/');
  const libraryHeading = page.locator("//*[text()='Book Library']");

  const libraryHeading = page.locator("//*[text()='Book Library']");
  await libraryHeading.waitFor({timeout: 5000});


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

passed

Positive => Verify book details page can be accessed using direct url

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:08 GMT
Total Execution Time	0h 0m 2s 524ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });


    await page.goto(firstBookUrl);
    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({ timeout: 3000 });


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toContain(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toContain(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toContain(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookISBN).toBe(book.isbn);

    expect(bookPages).toContain(book.pages);
    expect(bookISBN).toBe(book.isbn);
    expect(bookDescription).toContain(book.description);

    expect(bookISBN).toBe(book.isbn);
    expect(bookDescription).toContain(book.description);

passed

E2E => Homepage -> Details page -> Back to Library(using button)

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:09 GMT
Total Execution Time	0h 0m 2s 310ms
Retry	0
Test Info
Group	Verify navigations across all pages on app
Filename	ui_tests/navigation.spec.ts

test.describe('Verify navigations across all pages on app', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);
    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({timeout: 3000});


    await backButton.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();
  });

passed

Positive => GET /api/books/${bookid} fetches book in library using book id

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:11 GMT
Total Execution Time	0h 0m 0s 432ms
Retry	0
Test Info
Filename	api_tests/get-book-by-id.spec.ts

  const bookid = 2;
  const response = await request.get(`/api/books/${bookid}`);
  expect(response.ok()).toBeTruthy();

  const response = await request.get(`/api/books/${bookid}`);
  expect(response.ok()).toBeTruthy();

  const apiBook = await response.json();
  expect(apiBook.title).toBe(books[`${bookid-1}`].title);
  expect(apiBook.author).toBe(books[`${bookid-1}`].author);

  expect(apiBook.title).toBe(books[`${bookid-1}`].title);
  expect(apiBook.author).toBe(books[`${bookid-1}`].author);
  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);

  expect(apiBook.author).toBe(books[`${bookid-1}`].author);
  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);
  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);

  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);
  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);
  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));

  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);
  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));
  expect(apiBook.description).toContain(books[`${bookid-1}`].description);

  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));
  expect(apiBook.description).toContain(books[`${bookid-1}`].description);

passed

Negative => Verify book not found text is displayed for non existing book url

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:08 GMT
Total Execution Time	0h 0m 3s 153ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const bookUrl = pageUrl + 'book/999';
    const response = await page.goto(bookUrl);
    expect(response?.status()).toBe(200);

    const response = await page.goto(bookUrl);
    expect(response?.status()).toBe(200);

    const bookNotFoundText = await page.locator("text=Book not found").textContent();
    expect(bookNotFoundText).toBe('Book not found');

    const backButton = page.getByRole('link', { name: 'Back to Library' });
    await backButton.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();

passed

Negative => Missing required fields in POST /api/books throws 400 error

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:11 GMT
Total Execution Time	0h 0m 0s 518ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const payload = { title: 'POST books test' };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const payload2 = { author: 'Dummy Author' };
    const post2 = await request.post('/api/books', { data: payload2 });
    expect(post2.status()).toBe(400);

    const post2 = await request.post('/api/books', { data: payload2 });
    expect(post2.status()).toBe(400);

passed

Positive => GET /api/books fetches all books in library

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:11 GMT
Total Execution Time	0h 0m 0s 385ms
Retry	0
Test Info
Filename	api_tests/get-books.spec.ts

  
  const response = await request.get('/api/books');
  expect(response.ok()).toBeTruthy();

  const response = await request.get('/api/books');
  expect(response.ok()).toBeTruthy();

  // Verify count of books to be >= default books
  expect(apiBooks.length).toBeGreaterThanOrEqual(library.length);


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }

passed

Negative => Invalid path parameter in GET endpoint throws 404 error

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:12 GMT
Total Execution Time	0h 0m 0s 64ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    // Using invalid path parameter 'book' instead of 'books'
    const response = await request.get('/api/book/');
    expect(response.ok()).toBeFalsy();

    const response = await request.get('/api/book/');
    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

passed

Negative => GET /api/books/${bookid} return error if book id is not found

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:12 GMT
Total Execution Time	0h 0m 0s 389ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const bookid = 9999;
    const response = await request.get(`/api/books/${bookid}`);
    expect(response.ok()).toBeFalsy();

    const response = await request.get(`/api/books/${bookid}`);
    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

passed

Negative => Using only optional fields in payload in POST /api/books throws 400 error

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:12 GMT
Total Execution Time	0h 0m 0s 256ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const payload = { genre: 'Fiction' };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

passed

E2E => Homepage -> Details page -> Back to Library(using '←' link)

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:10 GMT
Total Execution Time	0h 0m 3s 21ms
Retry	0
Test Info
Group	Verify navigations across all pages on app
Filename	ui_tests/navigation.spec.ts

test.describe('Verify navigations across all pages on app', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({ timeout: 3000 });
    const bookTitle = await page.locator(`text=${firstBook.title}`).innerText();

    const bookTitle = await page.locator(`text=${firstBook.title}`).innerText();
    expect(bookTitle).toBe(firstBook.title);
    await backLink.click();

    expect(bookTitle).toBe(firstBook.title);
    await backLink.click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

passed

E2E => POST /api/books creates new book using all fields

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:12 GMT
Total Execution Time	0h 0m 3s 666ms
Retry	0
Test Info
Group	Validate POST /api/books/ endpoint and verify using GET API and UI (homepage + details)
Filename	api_tests/post-book.spec.ts

                  };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);
    const body = await post.json();

    const body = await post.json();
    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);

    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);

    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe(payload.genre);

    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe(payload.genre);
    expect(body.publishedYear).toBe(payload.publishedYear);

    expect(body.genre).toBe(payload.genre);
    expect(body.publishedYear).toBe(payload.publishedYear);
    expect(body.pages).toBe(payload.pages);

    expect(body.publishedYear).toBe(payload.publishedYear);
    expect(body.pages).toBe(payload.pages);
    expect(body.isbn).toBe(payload.isbn);

    expect(body.pages).toBe(payload.pages);
    expect(body.isbn).toBe(payload.isbn);
    expect(body.description).toContain(payload.description);

    expect(body.isbn).toBe(payload.isbn);
    expect(body.description).toContain(payload.description);

    // Verify the new book is present in the GET /api/books response
    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);

    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);
    const booksList = await getResponse.json();

    const createdBook = booksList.find((b: Book) => b.id === body.id);
    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);

    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    // Verify the new book is present in the GET /api/books/book.id response
    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);

    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);
    const getBook = await getBookResponse.json();

    const getBook = await getBookResponse.json();
    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);

    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe(payload.genre);

    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe(payload.genre);
    expect(getBook.publishedYear).toBe(payload.publishedYear);

    expect(getBook.genre).toBe(payload.genre);
    expect(getBook.publishedYear).toBe(payload.publishedYear);
    expect(getBook.pages).toBe(payload.pages);

    expect(getBook.publishedYear).toBe(payload.publishedYear);
    expect(getBook.pages).toBe(payload.pages);
    expect(getBook.isbn).toBe(payload.isbn);

    expect(getBook.pages).toBe(payload.pages);
    expect(getBook.isbn).toBe(payload.isbn);
    expect(getBook.description).toContain(payload.description);

    expect(getBook.isbn).toBe(payload.isbn);
    expect(getBook.description).toContain(payload.description);

    // Verify via UI that the new book is accessible on Library homepage and details page
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    const bookTitleLocator = page.locator(`text=${payload.title}`);

    const bookTitleLocator = page.locator(`text=${payload.title}`);
    await bookTitleLocator.scrollIntoViewIfNeeded()
    await bookTitleLocator.click();

    await bookTitleLocator.scrollIntoViewIfNeeded()
    await bookTitleLocator.click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitleOnDetails = await page.locator("//h1").innerText();

    const bookTitleOnDetails = await page.locator("//h1").innerText();
    expect(bookTitleOnDetails).toContain(payload.title);

passed

E2E => POST /api/books creates new book using only required fields

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:12 GMT
Total Execution Time	0h 0m 3s 686ms
Retry	0
Test Info
Group	Validate POST /api/books/ endpoint and verify using GET API and UI (homepage + details)
Filename	api_tests/post-book.spec.ts

                  };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);
    const body = await post.json();

    const body = await post.json();
    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);

    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);

    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe('Unknown');

    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe('Unknown');
    expect(body.publishedYear).toBe(2025);

    expect(body.genre).toBe('Unknown');
    expect(body.publishedYear).toBe(2025);
    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **

    expect(body.publishedYear).toBe(2025);
    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **
    expect(body.isbn).toBe('N/A');

    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **
    expect(body.isbn).toBe('N/A');
    expect(body.description).toContain('No description available.');

    expect(body.isbn).toBe('N/A');
    expect(body.description).toContain('No description available.');

    // Verify the new book is present in the GET /api/books response
    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);

    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);
    const booksList = await getResponse.json();

    const createdBook = booksList.find((b: Book) => b.id === body.id);
    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);

    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    // Verify the new book is present in the GET /api/books/book.id response
    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);

    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);
    const getBook = await getBookResponse.json();

    const getBook = await getBookResponse.json();
    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);

    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe('Unknown');

    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe('Unknown');
    expect(getBook.publishedYear).toBe(2025);

    expect(getBook.genre).toBe('Unknown');
    expect(getBook.publishedYear).toBe(2025);
    expect(getBook.pages).toBe(0);

    expect(getBook.publishedYear).toBe(2025);
    expect(getBook.pages).toBe(0);
    expect(getBook.isbn).toBe('N/A');

    expect(getBook.pages).toBe(0);
    expect(getBook.isbn).toBe('N/A');
    expect(getBook.description).toContain('No description available.');

    expect(getBook.isbn).toBe('N/A');
    expect(getBook.description).toContain('No description available.');

    // Verify via UI that the new book is accessible on Library homepage and details page
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    const bookTitleLocator = page.locator(`text=${payload.title}`);

    const bookTitleLocator = page.locator(`text=${payload.title}`);
    await bookTitleLocator.last().scrollIntoViewIfNeeded();
    await bookTitleLocator.last().click();

    await bookTitleLocator.last().scrollIntoViewIfNeeded();
    await bookTitleLocator.last().click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitleOnDetails = await page.locator("//h1").innerText();

    const bookTitleOnDetails = await page.locator("//h1").innerText();
    expect(bookTitleOnDetails).toContain(payload.title);
  });

passed

E2E => Verify all default books in library have matching details on Book detail page

Run Info
Project	webkit
Execution Start Time	Tue, 18 Nov 2025 15:03:07 GMT
Total Execution Time	0h 0m 9s 143ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

passed

E2E => Verify user is able Add new book from homepage

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:12 GMT
Total Execution Time	0h 0m 5s 565ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()

    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);

    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);

    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

passed

Negative => Verify error messages for required fields viz. Title, Author and Pages field on Add New Book form page

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:17 GMT
Total Execution Time	0h 0m 2s 284ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Verify error message for Title field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(titleErrorMessage);

    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(titleErrorMessage);
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);

    expect(validMessages).toContain(titleErrorMessage);
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);

    // Verify error message for Author field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(authorErrorMessage);

    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(authorErrorMessage);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    expect(validMessages).toContain(authorErrorMessage);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    // Verify error message for Pages field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(pagesErrorMessage);

    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(pagesErrorMessage);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    expect(validMessages).toContain(pagesErrorMessage);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

passed

E2E => Verify user is able Add new book from book details page

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:13 GMT
Total Execution Time	0h 0m 6s 14ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);

    const addAnotherBookButton = page.getByRole('link', { name: 'Add Another Book' });
    await addAnotherBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addAnotherBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()

    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);

    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);

    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

passed

Negative => Verify error messages for optional fields Published Year and Rating field on Add New Book form page

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:18 GMT
Total Execution Time	0h 0m 2s 225ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    // Verify error message for Published Year field
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('9999999');
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('9999999');
    await page.getByRole('button', { name: 'Add Book' }).click();
    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(yearErrorMessage);

    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(yearErrorMessage);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();

    expect(validMessages).toContain(yearErrorMessage);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('2020');

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('2020');

    // Verify error message for Rating field
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('8');
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('8');
    await page.getByRole('button', { name: 'Add Book' }).click();
    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(ratingErrorMessage);

    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(ratingErrorMessage);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    expect(validMessages).toContain(ratingErrorMessage);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('2');

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('2');

    // Verify error message for Pages field
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

passed

E2E => Create new book using only required fields

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:16 GMT
Total Execution Time	0h 0m 5s 70ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form using only required fields
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe('Unknown');

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe('Unknown');
    expect(bookPublishedYear).toContain('2025');

    expect(bookGenre).toBe('Unknown');
    expect(bookPublishedYear).toContain('2025');
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain('2025');
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe('N/A');

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe('N/A');
    expect(bookDescription).toContain('No description available.');

    expect(bookISBN).toBe('N/A');
    expect(bookDescription).toContain('No description available.');

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe('Unknown');

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe('Unknown');
    expect(newBookYear).toBe('2025');

    expect(newBookGenre).toBe('Unknown');
    expect(newBookYear).toBe('2025');
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe('2025');
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain('No description available.');

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain('No description available.');
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain('No description available.');
    await expect(newBookRating).toBeVisible();

passed

Positive => Clicking on View Details link opens book details page

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:20 GMT
Total Execution Time	0h 0m 2s 142ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const book = books[0];
    await page.locator(`//*[text()='${book.title}']//ancestor::a//*[contains(text(),'View details')]`).click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitle = await page.locator(`text=${book.title}`).textContent();

    const bookTitle = await page.locator(`text=${book.title}`).textContent();
    expect(bookTitle).toBe(`${book.title}`);
    await backLink.click();

    expect(bookTitle).toBe(`${book.title}`);
    await backLink.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();
  });

passed

Positive => Verify user is able to open newly added book on details page

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:16 GMT
Total Execution Time	0h 0m 5s 914ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form using only required fields
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({timeout: 3000});


    await backButton.click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    await page.locator("//*[contains(text(),'Interview preparation-')]").first().click();

    await libraryHeading.waitFor({timeout: 5000});
    await page.locator("//*[contains(text(),'Interview preparation-')]").first().click();


    await backButton.waitFor({ timeout: 3000 });
    const bookTitle = await page.locator("//h1").innerText();

    const bookTitle = await page.locator("//h1").innerText();
    expect(bookTitle).toContain('Interview preparation-');

passed

Positive => Clicking on Cancel button goes back to Library homepage

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:19 GMT
Total Execution Time	0h 0m 2s 274ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');


    await page.getByRole('link', { name: 'Cancel' }).click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});

passed

Positive => Displays details of all default books on Books Library homepage

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:22 GMT
Total Execution Time	0h 0m 1s 304ms
Retry	0
Test Info
Filename	ui_tests/library-homepage.spec.ts

  /** This test will verify each book's details on Library homepage **/
  await page.goto('/');
  const libraryHeading = page.locator("//*[text()='Book Library']");

  const libraryHeading = page.locator("//*[text()='Book Library']");
  await libraryHeading.waitFor({timeout: 5000});


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

passed

Positive => Verify book details page can be accessed using direct url

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:21 GMT
Total Execution Time	0h 0m 2s 252ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });


    await page.goto(firstBookUrl);
    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({ timeout: 3000 });


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toContain(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toContain(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toContain(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookISBN).toBe(book.isbn);

    expect(bookPages).toContain(book.pages);
    expect(bookISBN).toBe(book.isbn);
    expect(bookDescription).toContain(book.description);

    expect(bookISBN).toBe(book.isbn);
    expect(bookDescription).toContain(book.description);

passed

E2E => Homepage -> Details page -> Back to Library(using button)

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:22 GMT
Total Execution Time	0h 0m 2s 272ms
Retry	0
Test Info
Group	Verify navigations across all pages on app
Filename	ui_tests/navigation.spec.ts

test.describe('Verify navigations across all pages on app', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);
    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({timeout: 3000});


    await backButton.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();
  });

passed

Positive => GET /api/books/${bookid} fetches book in library using book id

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:24 GMT
Total Execution Time	0h 0m 0s 408ms
Retry	0
Test Info
Filename	api_tests/get-book-by-id.spec.ts

  const bookid = 2;
  const response = await request.get(`/api/books/${bookid}`);
  expect(response.ok()).toBeTruthy();

  const response = await request.get(`/api/books/${bookid}`);
  expect(response.ok()).toBeTruthy();

  const apiBook = await response.json();
  expect(apiBook.title).toBe(books[`${bookid-1}`].title);
  expect(apiBook.author).toBe(books[`${bookid-1}`].author);

  expect(apiBook.title).toBe(books[`${bookid-1}`].title);
  expect(apiBook.author).toBe(books[`${bookid-1}`].author);
  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);

  expect(apiBook.author).toBe(books[`${bookid-1}`].author);
  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);
  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);

  expect(apiBook.genre).toBe(books[`${bookid-1}`].genre);
  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);
  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));

  expect(String(apiBook.publishedYear)).toBe(books[`${bookid-1}`].year);
  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));
  expect(apiBook.description).toContain(books[`${bookid-1}`].description);

  expect(String(apiBook.pages)).toBe(String(books[`${bookid-1}`].pages));
  expect(apiBook.description).toContain(books[`${bookid-1}`].description);

passed

Negative => Missing required fields in POST /api/books throws 400 error

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:24 GMT
Total Execution Time	0h 0m 0s 517ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const payload = { title: 'POST books test' };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const payload2 = { author: 'Dummy Author' };
    const post2 = await request.post('/api/books', { data: payload2 });
    expect(post2.status()).toBe(400);

    const post2 = await request.post('/api/books', { data: payload2 });
    expect(post2.status()).toBe(400);

passed

Negative => Verify book not found text is displayed for non existing book url

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:22 GMT
Total Execution Time	0h 0m 3s 99ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const bookUrl = pageUrl + 'book/999';
    const response = await page.goto(bookUrl);
    expect(response?.status()).toBe(200);

    const response = await page.goto(bookUrl);
    expect(response?.status()).toBe(200);

    const bookNotFoundText = await page.locator("text=Book not found").textContent();
    expect(bookNotFoundText).toBe('Book not found');

    const backButton = page.getByRole('link', { name: 'Back to Library' });
    await backButton.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();

passed

Negative => Using only optional fields in payload in POST /api/books throws 400 error

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:25 GMT
Total Execution Time	0h 0m 0s 258ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const payload = { genre: 'Fiction' };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(400);

passed

Positive => GET /api/books fetches all books in library

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:24 GMT
Total Execution Time	0h 0m 0s 371ms
Retry	0
Test Info
Filename	api_tests/get-books.spec.ts

  
  const response = await request.get('/api/books');
  expect(response.ok()).toBeTruthy();

  const response = await request.get('/api/books');
  expect(response.ok()).toBeTruthy();

  // Verify count of books to be >= default books
  expect(apiBooks.length).toBeGreaterThanOrEqual(library.length);


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }


  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);

  expect(apiBook.title).toBe(book.title);
  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);

  expect(apiBook.author).toBe(book.author);
  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);

  expect(apiBook.genre).toBe(book.genre);
  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));

  expect(String(apiBook.publishedYear)).toBe(book.year);
  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);

  expect(String(apiBook.pages)).toBe(String(book.pages));
  expect(apiBook.description).toContain(book.description);
  }

passed

Negative => Invalid path parameter in GET endpoint throws 404 error

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:25 GMT
Total Execution Time	0h 0m 0s 76ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    // Using invalid path parameter 'book' instead of 'books'
    const response = await request.get('/api/book/');
    expect(response.ok()).toBeFalsy();

    const response = await request.get('/api/book/');
    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

passed

Negative => GET /api/books/${bookid} return error if book id is not found

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:25 GMT
Total Execution Time	0h 0m 0s 410ms
Retry	0
Test Info
Group	Validate negative scenarios of GET & POST endpoints
Filename	api_tests/negative-api.spec.ts

    const bookid = 9999;
    const response = await request.get(`/api/books/${bookid}`);
    expect(response.ok()).toBeFalsy();

    const response = await request.get(`/api/books/${bookid}`);
    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

    expect(response.ok()).toBeFalsy();
    expect(response.status()).toBe(404);

passed

E2E => Homepage -> Details page -> Back to Library(using '←' link)

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:23 GMT
Total Execution Time	0h 0m 2s 928ms
Retry	0
Test Info
Group	Verify navigations across all pages on app
Filename	ui_tests/navigation.spec.ts

test.describe('Verify navigations across all pages on app', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({ timeout: 3000 });
    const bookTitle = await page.locator(`text=${firstBook.title}`).innerText();

    const bookTitle = await page.locator(`text=${firstBook.title}`).innerText();
    expect(bookTitle).toBe(firstBook.title);
    await backLink.click();

    expect(bookTitle).toBe(firstBook.title);
    await backLink.click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

passed

E2E => POST /api/books creates new book using all fields

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:25 GMT
Total Execution Time	0h 0m 3s 728ms
Retry	0
Test Info
Group	Validate POST /api/books/ endpoint and verify using GET API and UI (homepage + details)
Filename	api_tests/post-book.spec.ts

                  };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);
    const body = await post.json();

    const body = await post.json();
    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);

    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);

    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe(payload.genre);

    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe(payload.genre);
    expect(body.publishedYear).toBe(payload.publishedYear);

    expect(body.genre).toBe(payload.genre);
    expect(body.publishedYear).toBe(payload.publishedYear);
    expect(body.pages).toBe(payload.pages);

    expect(body.publishedYear).toBe(payload.publishedYear);
    expect(body.pages).toBe(payload.pages);
    expect(body.isbn).toBe(payload.isbn);

    expect(body.pages).toBe(payload.pages);
    expect(body.isbn).toBe(payload.isbn);
    expect(body.description).toContain(payload.description);

    expect(body.isbn).toBe(payload.isbn);
    expect(body.description).toContain(payload.description);

    // Verify the new book is present in the GET /api/books response
    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);

    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);
    const booksList = await getResponse.json();

    const createdBook = booksList.find((b: Book) => b.id === body.id);
    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);

    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    // Verify the new book is present in the GET /api/books/book.id response
    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);

    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);
    const getBook = await getBookResponse.json();

    const getBook = await getBookResponse.json();
    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);

    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe(payload.genre);

    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe(payload.genre);
    expect(getBook.publishedYear).toBe(payload.publishedYear);

    expect(getBook.genre).toBe(payload.genre);
    expect(getBook.publishedYear).toBe(payload.publishedYear);
    expect(getBook.pages).toBe(payload.pages);

    expect(getBook.publishedYear).toBe(payload.publishedYear);
    expect(getBook.pages).toBe(payload.pages);
    expect(getBook.isbn).toBe(payload.isbn);

    expect(getBook.pages).toBe(payload.pages);
    expect(getBook.isbn).toBe(payload.isbn);
    expect(getBook.description).toContain(payload.description);

    expect(getBook.isbn).toBe(payload.isbn);
    expect(getBook.description).toContain(payload.description);

    // Verify via UI that the new book is accessible on Library homepage and details page
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    const bookTitleLocator = page.locator(`text=${payload.title}`);

    const bookTitleLocator = page.locator(`text=${payload.title}`);
    await bookTitleLocator.scrollIntoViewIfNeeded()
    await bookTitleLocator.click();

    await bookTitleLocator.scrollIntoViewIfNeeded()
    await bookTitleLocator.click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitleOnDetails = await page.locator("//h1").innerText();

    const bookTitleOnDetails = await page.locator("//h1").innerText();
    expect(bookTitleOnDetails).toContain(payload.title);

passed

E2E => POST /api/books creates new book using only required fields

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:25 GMT
Total Execution Time	0h 0m 3s 772ms
Retry	0
Test Info
Group	Validate POST /api/books/ endpoint and verify using GET API and UI (homepage + details)
Filename	api_tests/post-book.spec.ts

                  };
    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);

    const post = await request.post('/api/books', { data: payload });
    expect(post.status()).toBe(201);
    const body = await post.json();

    const body = await post.json();
    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);

    expect(body).toHaveProperty('id');
    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);

    expect(body.title).toBe(payload.title);
    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe('Unknown');

    expect(body.author).toBe(payload.author);
    expect(body.genre).toBe('Unknown');
    expect(body.publishedYear).toBe(2025);

    expect(body.genre).toBe('Unknown');
    expect(body.publishedYear).toBe(2025);
    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **

    expect(body.publishedYear).toBe(2025);
    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **
    expect(body.isbn).toBe('N/A');

    expect(body.pages).toBe(0); // ** Bug found: should not create a book with 0 pages **
    expect(body.isbn).toBe('N/A');
    expect(body.description).toContain('No description available.');

    expect(body.isbn).toBe('N/A');
    expect(body.description).toContain('No description available.');

    // Verify the new book is present in the GET /api/books response
    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);

    const getResponse = await request.get('/api/books/');
    expect(getResponse.status()).toBe(200);
    const booksList = await getResponse.json();

    const createdBook = booksList.find((b: Book) => b.id === body.id);
    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);

    expect(createdBook).toBeDefined();
    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    expect(createdBook.title).toBe(payload.title);
    expect(createdBook.author).toBe(payload.author);

    // Verify the new book is present in the GET /api/books/book.id response
    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);

    const getBookResponse = await request.get(`/api/books/${body.id}`);
    expect(getBookResponse.status()).toBe(200);
    const getBook = await getBookResponse.json();

    const getBook = await getBookResponse.json();
    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);

    expect(getBook.title).toBe(payload.title);
    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe('Unknown');

    expect(getBook.author).toBe(payload.author);
    expect(getBook.genre).toBe('Unknown');
    expect(getBook.publishedYear).toBe(2025);

    expect(getBook.genre).toBe('Unknown');
    expect(getBook.publishedYear).toBe(2025);
    expect(getBook.pages).toBe(0);

    expect(getBook.publishedYear).toBe(2025);
    expect(getBook.pages).toBe(0);
    expect(getBook.isbn).toBe('N/A');

    expect(getBook.pages).toBe(0);
    expect(getBook.isbn).toBe('N/A');
    expect(getBook.description).toContain('No description available.');

    expect(getBook.isbn).toBe('N/A');
    expect(getBook.description).toContain('No description available.');

    // Verify via UI that the new book is accessible on Library homepage and details page
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    const bookTitleLocator = page.locator(`text=${payload.title}`);

    const bookTitleLocator = page.locator(`text=${payload.title}`);
    await bookTitleLocator.last().scrollIntoViewIfNeeded();
    await bookTitleLocator.last().click();

    await bookTitleLocator.last().scrollIntoViewIfNeeded();
    await bookTitleLocator.last().click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitleOnDetails = await page.locator("//h1").innerText();

    const bookTitleOnDetails = await page.locator("//h1").innerText();
    expect(bookTitleOnDetails).toContain(payload.title);
  });

passed

E2E => Verify all default books in library have matching details on Book detail page

Run Info
Project	Mobile Chrome
Execution Start Time	Tue, 18 Nov 2025 15:03:20 GMT
Total Execution Time	0h 0m 9s 75ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

passed

E2E => Verify user is able Add new book from homepage

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:26 GMT
Total Execution Time	0h 0m 5s 101ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()

    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);

    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);

    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

passed

Negative => Verify error messages for required fields viz. Title, Author and Pages field on Add New Book form page

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:30 GMT
Total Execution Time	0h 0m 2s 654ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Verify error message for Title field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(titleErrorMessage);

    const titleErrorMessage = await page.locator('#title').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(titleErrorMessage);
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);

    expect(validMessages).toContain(titleErrorMessage);
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);

    // Verify error message for Author field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(authorErrorMessage);

    const authorErrorMessage = await page.locator('#author').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(authorErrorMessage);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    expect(validMessages).toContain(authorErrorMessage);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    // Verify error message for Pages field
    await page.getByRole('button', { name: 'Add Book' }).click();
    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(pagesErrorMessage);

    const pagesErrorMessage = await page.locator('#pages').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(pagesErrorMessage);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    expect(validMessages).toContain(pagesErrorMessage);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

passed

E2E => Verify user is able Add new book from book details page

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:26 GMT
Total Execution Time	0h 0m 6s 171ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);

    const addAnotherBookButton = page.getByRole('link', { name: 'Add Another Book' });
    await addAnotherBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addAnotherBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()

    await page.getByLabel('Genre').selectOption(genre);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear()
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill(year);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    await page.getByRole('textbox', { name: 'ISBN' }).fill(isbn);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill(rating);
    await page.getByRole('textbox', { name: 'Description' }).fill(description);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);

    expect(bookGenre).toBe(genre);
    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain(year);
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    expect(bookISBN).toBe(isbn);
    expect(bookDescription).toContain(description);

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);

    expect(newBookGenre).toBe(genre);
    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe(year);
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain(description);
    await expect(newBookRating).toBeVisible();

passed

Negative => Verify error messages for optional fields Published Year and Rating field on Add New Book form page

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:31 GMT
Total Execution Time	0h 0m 2s 327ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    // Verify error message for Published Year field
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('9999999');
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('9999999');
    await page.getByRole('button', { name: 'Add Book' }).click();
    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(yearErrorMessage);

    const yearErrorMessage = await page.locator('#publishedYear').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(yearErrorMessage);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();

    expect(validMessages).toContain(yearErrorMessage);
    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('2020');

    await page.getByRole('spinbutton', { name: 'Published Year' }).clear();
    await page.getByRole('spinbutton', { name: 'Published Year' }).fill('2020');

    // Verify error message for Rating field
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('8');
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('8');
    await page.getByRole('button', { name: 'Add Book' }).click();
    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);

    await page.getByRole('button', { name: 'Add Book' }).click();
    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(ratingErrorMessage);

    const ratingErrorMessage = await page.locator('#rating').evaluate((el: HTMLInputElement) => el.validationMessage);
    expect(validMessages).toContain(ratingErrorMessage);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();

    expect(validMessages).toContain(ratingErrorMessage);
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('2');

    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).clear();
    await page.getByRole('spinbutton', { name: 'Rating (1-5)' }).fill('2');

    // Verify error message for Pages field
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

passed

E2E => Create new book using only required fields

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:29 GMT
Total Execution Time	0h 0m 5s 159ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form using only required fields
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');


    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);

    expect(bookTitle).toBe(title);
    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe('Unknown');

    expect(bookAuthor).toContain(author);
    expect(bookGenre).toBe('Unknown');
    expect(bookPublishedYear).toContain('2025');

    expect(bookGenre).toBe('Unknown');
    expect(bookPublishedYear).toContain('2025');
    expect(bookPages).toContain(pages);

    expect(bookPublishedYear).toContain('2025');
    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe('N/A');

    expect(bookPages).toContain(pages);
    expect(bookISBN).toBe('N/A');
    expect(bookDescription).toContain('No description available.');

    expect(bookISBN).toBe('N/A');
    expect(bookDescription).toContain('No description available.');

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.click();
    const newBookTitle = await page.locator(`text=${title}`).innerText();


    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);

    expect(newBookTitle).toBe(title);
    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe('Unknown');

    expect(newBookAuthor).toContain(author);
    expect(newBookGenre).toBe('Unknown');
    expect(newBookYear).toBe('2025');

    expect(newBookGenre).toBe('Unknown');
    expect(newBookYear).toBe('2025');
    expect(newBookPages).toContain(pages);

    expect(newBookYear).toBe('2025');
    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain('No description available.');

    expect(newBookPages).toContain(pages);
    expect(newBookDescription).toContain('No description available.');
    await expect(newBookRating).toBeVisible();

    expect(newBookDescription).toContain('No description available.');
    await expect(newBookRating).toBeVisible();

passed

Positive => Clicking on Cancel button goes back to Library homepage

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:32 GMT
Total Execution Time	0h 0m 2s 307ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');


    await page.getByRole('link', { name: 'Cancel' }).click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});

passed

Positive => Verify user is able to open newly added book on details page

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:29 GMT
Total Execution Time	0h 0m 5s 987ms
Retry	0
Test Info
Group	Add New Book form page
Filename	ui_tests/add-book.spec.ts

test.describe('Add New Book form page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const addNewBookButton = page.getByRole('link', { name: 'Add New Book' });
    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });

    await addNewBookButton.click();
    await page.getByRole('button', { name: 'Add Book' }).waitFor({ timeout: 3000 });
    const addBookHeading = page.locator("//form/preceding-sibling::h1");

    const addBookHeading = page.locator("//form/preceding-sibling::h1");
    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    await addBookHeading.waitFor({ timeout: 3000 });
    expect(await addBookHeading.textContent()).toBe('Add New Book');

    // Fill the Add New Book form using only required fields
    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);

    await page.getByRole('textbox', { name: 'Title *' }).fill(title);
    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();

    await page.getByRole('textbox', { name: 'Author *' }).fill(author);
    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    await page.getByRole('spinbutton', { name: 'Pages' }).clear();
    await page.getByRole('spinbutton', { name: 'Pages' }).fill(pages);

    // Submit the form
    await page.getByRole('button', { name: 'Add Book' }).click();

    const successMessage = page.locator("text=Book Added Successfully!");
    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    await successMessage.waitFor({ timeout: 2000 });
    expect(await successMessage.textContent()).toBe('Book Added Successfully!');

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({timeout: 3000});


    await backButton.click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
    await page.locator("//*[contains(text(),'Interview preparation-')]").first().click();

    await libraryHeading.waitFor({timeout: 5000});
    await page.locator("//*[contains(text(),'Interview preparation-')]").first().click();


    await backButton.waitFor({ timeout: 3000 });
    const bookTitle = await page.locator("//h1").innerText();

    const bookTitle = await page.locator("//h1").innerText();
    expect(bookTitle).toContain('Interview preparation-');

passed

Positive => Clicking on View Details link opens book details page

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:33 GMT
Total Execution Time	0h 0m 2s 181ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const book = books[0];
    await page.locator(`//*[text()='${book.title}']//ancestor::a//*[contains(text(),'View details')]`).click();
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({timeout: 3000});
    const bookTitle = await page.locator(`text=${book.title}`).textContent();

    const bookTitle = await page.locator(`text=${book.title}`).textContent();
    expect(bookTitle).toBe(`${book.title}`);
    await backLink.click();

    expect(bookTitle).toBe(`${book.title}`);
    await backLink.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();
  });

passed

Positive => Displays details of all default books on Books Library homepage

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:35 GMT
Total Execution Time	0h 0m 1s 370ms
Retry	0
Test Info
Filename	ui_tests/library-homepage.spec.ts

  /** This test will verify each book's details on Library homepage **/
  await page.goto('/');
  const libraryHeading = page.locator("//*[text()='Book Library']");

  const libraryHeading = page.locator("//*[text()='Book Library']");
  await libraryHeading.waitFor({timeout: 5000});


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toBe(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);

    expect(bookPages).toContain(book.pages);
    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

    expect(bookDescription).toContain(book.description);
    await expect(bookRating).toBeVisible();

passed

Positive => Verify book details page can be accessed using direct url

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:34 GMT
Total Execution Time	0h 0m 2s 346ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });


    await page.goto(firstBookUrl);
    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({ timeout: 3000 });


    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);

    expect(bookTitle).toBe(book.title);
    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);

    expect(bookAuthor).toContain(book.author);
    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toContain(book.year);

    expect(bookGenre).toBe(book.genre);
    expect(bookPublishedYear).toContain(book.year);
    expect(bookPages).toContain(book.pages);

    expect(bookPublishedYear).toContain(book.year);
    expect(bookPages).toContain(book.pages);
    expect(bookISBN).toBe(book.isbn);

    expect(bookPages).toContain(book.pages);
    expect(bookISBN).toBe(book.isbn);
    expect(bookDescription).toContain(book.description);

    expect(bookISBN).toBe(book.isbn);
    expect(bookDescription).toContain(book.description);

passed

E2E => Homepage -> Details page -> Back to Library(using button)

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:35 GMT
Total Execution Time	0h 0m 2s 171ms
Retry	0
Test Info
Group	Verify navigations across all pages on app
Filename	ui_tests/navigation.spec.ts

test.describe('Verify navigations across all pages on app', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);
    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });

    const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
    await backButton.waitFor({timeout: 3000});


    await backButton.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();
  });

passed

Negative => Verify book not found text is displayed for non existing book url

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:35 GMT
Total Execution Time	0h 0m 3s 65ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const bookUrl = pageUrl + 'book/999';
    const response = await page.goto(bookUrl);
    expect(response?.status()).toBe(200);

    const response = await page.goto(bookUrl);
    expect(response?.status()).toBe(200);

    const bookNotFoundText = await page.locator("text=Book not found").textContent();
    expect(bookNotFoundText).toBe('Book not found');

    const backButton = page.getByRole('link', { name: 'Back to Library' });
    await backButton.click();
    const libraryHeading = page.locator("//h1");

    const libraryHeading = page.locator("//h1");
    await expect(libraryHeading).toBeVisible();

passed

E2E => Homepage -> Details page -> Back to Library(using '←' link)

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:36 GMT
Total Execution Time	0h 0m 2s 984ms
Retry	0
Test Info
Group	Verify navigations across all pages on app
Filename	ui_tests/navigation.spec.ts

test.describe('Verify navigations across all pages on app', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

    const firstBook = books[0];
    await page.click(`text=${firstBook.title}`);
    const backLink = page.getByRole('link', { name: '← Back to Library' });

    const backLink = page.getByRole('link', { name: '← Back to Library' });
    await backLink.waitFor({ timeout: 3000 });
    const bookTitle = await page.locator(`text=${firstBook.title}`).innerText();

    const bookTitle = await page.locator(`text=${firstBook.title}`).innerText();
    expect(bookTitle).toBe(firstBook.title);
    await backLink.click();

    expect(bookTitle).toBe(firstBook.title);
    await backLink.click();
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

passed

E2E => Verify all default books in library have matching details on Book detail page

Run Info
Project	Mobile Safari
Execution Start Time	Tue, 18 Nov 2025 15:03:33 GMT
Total Execution Time	0h 0m 8s 835ms
Retry	0
Test Info
Group	Books Details page
Filename	ui_tests/book-details.spec.ts

test.describe('Books Details page', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/');

  test.beforeEach(async ({ page }) => {
    await page.goto('/');
    const libraryHeading = page.locator("//*[text()='Book Library']");

    const libraryHeading = page.locator("//*[text()='Book Library']");
    await libraryHeading.waitFor({timeout: 5000});
  });

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

      const currentBook = books[i];
      await page.click(`text=${currentBook.title}`);

      const backButton = page.getByRole('link', { name: 'Back to Library', exact: true });
      await backButton.waitFor({ timeout: 3000 });


      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);

      expect(bookTitle).toBe(currentBook.title);
      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);

      expect(bookAuthor).toContain(currentBook.author);
      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);

      expect(bookGenre).toBe(currentBook.genre);
      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);

      expect(bookPublishedYear).toContain(currentBook.year);
      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);

      expect(bookPages).toContain(currentBook.pages);
      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);

      expect(bookISBN).toBe(currentBook.isbn);
      expect(bookDescription).toContain(currentBook.description);


      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();

      await backButton.click();
      await expect(page.locator("//h1")).toBeVisible();
    }

Fixture "request"0h 0m 0s 3ms

Create request context0h 0m 0s 1ms

Fixture "request"0h 0m 0s 2ms

Fixture "request"0h 0m 0s 0ms

Create request context0h 0m 0s 0ms

Fixture "request"0h 0m 0s 0ms

Fixture "request"0h 0m 0s 3ms

Create request context0h 0m 0s 1ms

Fixture "request"0h 0m 0s 3ms

Fixture "request"0h 0m 0s 3ms

Create request context0h 0m 0s 2ms

Fixture "request"0h 0m 0s 1ms

Fixture "request"0h 0m 0s 4ms

Create request context0h 0m 0s 1ms

Fixture "request"0h 0m 0s 2ms

Fixture "request"0h 0m 0s 3ms

Create request context0h 0m 0s 1ms

Fixture "request"0h 0m 0s 1ms

Fixture "request"0h 0m 0s 1ms

Create request context0h 0m 0s 1ms

Fixture "browser"0h 0m 0s 255ms

Launch browser0h 0m 0s 254ms

Fixture "context"0h 0m 0s 6ms

Create context0h 0m 0s 5ms

Fixture "page"0h 0m 0s 188ms

Create page0h 0m 0s 187ms

Fixture "page"0h 0m 0s 0ms

Fixture "context"0h 0m 0s 45ms

Close context0h 0m 0s 18ms

Fixture "request"0h 0m 0s 0ms

Fixture "request"0h 0m 0s 1ms

Create request context0h 0m 0s 1ms

Fixture "browser"0h 0m 0s 290ms

Launch browser0h 0m 0s 289ms

Fixture "context"0h 0m 0s 6ms

Create context0h 0m 0s 5ms

Fixture "page"0h 0m 0s 188ms

Create page0h 0m 0s 188ms